package com.koocloud.electroplatemanage.auth.controller;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.koocloud.electroplatemanage.auth.service.IPermissionService;
import com.koocloud.electroplatemanage.auth.service.IRoleService;
import com.koocloud.electroplatemanage.auth.service.IUserService;
import com.koocloud.electroplatemanage.common.pojo.ResponseTemplate;
import com.koocloud.electroplatemanage.common.util.CommonUtils;
import com.koocloud.electroplatemanage.common.util.ListPagingUtil;
import com.koocloud.electroplatemanage.pojo.*;
import com.koocloud.electroplatemanage.utils.ListUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;

/**
 * 控制菜单展示
 *
 * @author yxx
 */
@Controller
public class AuthorityController {
    private static Logger log = LoggerFactory.getLogger("auth");
    @Autowired
    IUserService IUserService;
    @Autowired
    IRoleService iRoleService;
    @Autowired
    IPermissionService iPermissionService;

    /**
     * 获取组织架构
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/selectOrganizationStruct", method = RequestMethod.POST, name = "获取组织架构")
    public ResponseTemplate selectOrganizationStruct() {
        log.info("开始增加用户");

        List<User> list = IUserService.selectOrganizationStruct();
        return ResponseTemplate.builder().code(0).data(list).build(); // code 0 代表成功 code1 代表失败;

    }

    /**
     * 维护组织架构
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/maintainOrganizationStruct", method = RequestMethod.POST, name = "维护组织架构")
    public ResponseTemplate maintainOrganizationStruct(String userName) {
        log.info("开始维护组织架构");
        // 维护组织架构 获取下拉菜单的所有用户 通过判断选择的用户名是否为空，为空的话查询所有用户，不为空的话选择除了该用户名以外的用户
        List<User> list = IUserService.maintainOrganizationStruct(userName);
        log.info("维护组织架构结束");
        return ResponseTemplate.builder().code(0).data(list).build(); // code 0 代表成功 code1 代表失败;

    }

    /**
     * 获取全部上级id 除了自己的
     */
    @ResponseBody
    @RequestMapping(value = "/getSuperiorLeaderIds", method = RequestMethod.POST, name = "修改用户")
    public ResponseTemplate getSuperiorLeaderIds(HttpServletRequest request) {
        log.info("开始获取全部上级id除了当前登录人自己的");
        User user = (User) request.getSession().getAttribute("token");
        List<User> userList = new ArrayList<>();
        if (!StringUtils.isEmpty(user)) {
            long id = user.getId();
            userList = IUserService.getSuperiorLeaderIds(id);
            User user2 = new User();
            user2.setId(-1);
            userList.add(0, user2);
        }
        log.info("获取全部上级id除了当前登录人自己的结束");
        if (!ListUtil.isEmpty(userList)) {
            return ResponseTemplate.builder().code(0).data(userList).build(); // code 0 代表成功 code1 代表失败
        } else {
            return ResponseTemplate.builder().code(1).message("获取全部上级id除了当前登录人自己的为空").build();
        }

    }

    // ------用户管理系统

    /**
     * 增加用户 userName 用户名 password 密码 jobNum 工号 fullName 用户姓名 汉字（用作显示） regPhone 注册手机号
     * superiorId 上级iddepartmentId线体
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/addUser", method = RequestMethod.POST, name = "增加用户")
    public ResponseTemplate addUser(String userName, String password, String jobNum, String fullName, String regPhone,
                                    String superiorId,String departmentId) {
        log.info("开始增加用户");
        log.info("传入的参数为userName:{},password:{},jobNum:{},fullName:{},regPhone:{},superiorId:{},departmentId:{}", userName, password,
                jobNum, fullName, regPhone, superiorId,departmentId);
        if (StringUtils.isEmpty(userName) || StringUtils.isEmpty(password)) {
            return ResponseTemplate.builder().code(1).message("输入的用户名和密码不能为空").build();
        } else {
            List<Map<String, Object>> list = IUserService.selectUserByName(userName);
            if (!StringUtils.isEmpty(list) && list.size() > 0) {
                return ResponseTemplate.builder().code(1).message("用户名已存在,请重新添加").build();
            } else {
                Integer num = IUserService.addUser(userName, password, fullName, jobNum, regPhone, superiorId,departmentId);
                log.info("增加用户结束");
                if (num > 0) {
                    return ResponseTemplate.builder().code(0).build(); // code 0 代表成功 code1 代表失败
                } else {
                    return ResponseTemplate.builder().code(1).message("工号必须以大写字母开头，其余为数字，长度为7位。").build();
                }
            }
        }
    }

    /**
     * 增加用户(旭鑫调用)
     *
     * @param request
     * @param response
     * @param model
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/addUserInfo", method = RequestMethod.POST, name = "增加用户")
    public String addUserInfo(String id, String userName) {
        log.info("开始增加用户");
        log.info("传入的参数为id:{},password:{}", userName);
        String password = "123456";
        if (StringUtils.isEmpty(userName)) {
            return "传入的用户名为空";
        } else {
            List<Map<String, Object>> list = IUserService.selectUserByName(userName);
            if (!StringUtils.isEmpty(list) && list.size() > 0) {
                return "用户名已存在";
            } else {
                String md5 = CommonUtils.md5(password);
                Integer num = IUserService.addUserInfo(id, userName, md5);
                log.info("增加用户结束");
                if (num > 0) {
                    return "true"; // code 0 代表成功 code1 代表失败
                } else {
                    return "false";
                }
            }
        }
    }

    /**
     * 修改用户 id 用户id userName 用户姓名 jobNum 工号 fullName 用户姓名（用于显示的姓名汉字） regPhone 注册手机号
     * superiorId 上级的id departmentId线体
     */
    @ResponseBody
    @RequestMapping(value = "/updateUser", method = RequestMethod.POST, name = "修改用户")
    public ResponseTemplate updateUser(String id, String userName, String password,String jobNum, String fullName, String regPhone,
                                       String superiorId,String departmentId) {
        /**
         * 根据用户id进行修改用户
         */
        log.info("开始修改用户");
        log.info("传入的参数为id:{},userName:{},jobNum:{},fullName:{},regPhone:{},superiorId:{},departmentId:{}", id, userName, jobNum,
                fullName, regPhone, superiorId,departmentId);
        if (StringUtils.isEmpty(userName)) {
            return ResponseTemplate.builder().code(1).message("用户名不能为空").build();
        } else {
            Integer num = IUserService.updateUser(id, userName, password,jobNum, fullName, regPhone, superiorId,departmentId);
            log.info("修改用户结束");
            if (num > 0) {
                return ResponseTemplate.builder().code(0).build(); // code 0 代表成功 code1 代表失败
            } else {
                return ResponseTemplate.builder().code(1).message("根据用户id进行修改用户异常").build();
            }
        }
    }

    /**
     * 根据多查询条件查询用户 idOrName 用户id/用户姓名/工号/用户显示的姓名（汉字）/注册手机号 page 第几页 limit 每页的大小
     */
    @ResponseBody
    @RequestMapping(value = "/selectUser", method = RequestMethod.POST, name = "查询用户")
    public ResponseTemplate selectUser(String idOrName, Integer page, Integer limit) {
        /**
         * 根据多条件查询用户
         */
        log.info("开始根据多查询条件查询用户");
        log.info("传入的参数为idOrName:{},page:{},limit:{}", idOrName, page, limit);
        List<User> list = IUserService.selectUser(idOrName);
        List paging = ListPagingUtil.listPaging(list, page, limit);
        log.info("根据多查询条件查询用户结束");
        if (!StringUtils.isEmpty(list)) {
            return ResponseTemplate.builder().code(0).count(Long.valueOf(list.size())).data(paging).build();
        } else {
            return ResponseTemplate.builder().code(1).message("根据多查询条件查询用户异常").count(Long.valueOf(list.size())).data(paging).build();
        }
    }

    /**
     * 根据id查询用户
     *
     * @param request
     * @param response
     * @param model
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/selectUserInfoById", method = RequestMethod.POST, name = "查询用户")
    public ResponseTemplate selectUserInfoById(int id) {
        /**
         * 根据多条件查询用户
         */
        log.info("开始根据id查询用户");
        log.info("传入的参数为id:{}", id);
        User user = IUserService.selectUserById(id);
        if (!StringUtils.isEmpty(user)) {
            return ResponseTemplate.builder().code(0).data(user).build();
        } else {
            return ResponseTemplate.builder().code(1).message("根据id查询用户异常").build();
        }

    }

    /**
     * 根据用户id删除用户
     */
    @ResponseBody
    @RequestMapping(value = "/deleteUser", method = RequestMethod.POST, name = "删除用户")
    public ResponseTemplate deleteUser(String id,String enableFlag) {
        /**
         * 根据用户id删除用户
         */
        log.info("开始根据用户id删除用户");
        log.info("传入的参数为id:{}", id);
        Integer num = IUserService.deleteUser(id, Integer.parseInt(enableFlag));
        log.info("根据用户id删除用户结束");
        if (num > 0) {
            return ResponseTemplate.builder().code(0).build();
        } else {
            return ResponseTemplate.builder().code(1).message("根据用户id删除用户异常").build();
        }
    }

    /**
     * 根据用户id获取已有的角色 和未有的角色列表 （弃用）
     */
    @ResponseBody
    @RequestMapping(value = "/selectRoleList", name = "查询角色列表")
    public Map<String, Object> selectRoleList(String id) {
        /**
         * 根据用户id获取已有的角色 和未有的角色列表
         */
        log.info("开始根据用户id获取已有的角色 和未有的角色列表");
        log.info("传入的参数为id:{}", id);
        Map<String, Object> map = IUserService.selectRoleList(id);
        log.info("根据用户id获取已有的角色 和未有的角色列表结束");
        return map;
    }

    /**
     * 根据用户id分配对应的角色(弃用)
     */
    @ResponseBody
    @RequestMapping(value = "/insertRoleList", name = "分配角色列表")
    public ResponseTemplate insertRoleList(String id, String hasRoleList) {
        log.info("开始根据用户id分配对应的角色");
        log.info("传入的参数为id:{},hasRoleList:{}", id, hasRoleList);
        /**
         * 根据用户id分配角色列表
         */
        Boolean boolean1 = IUserService.insertRoleList(id, hasRoleList);
        log.info("根据用户id分配对应的角色结束");
        if (boolean1 == true) {
            return ResponseTemplate.builder().code(0).build();
        } else {
            return ResponseTemplate.builder().code(1).message("根据用户id分配对应的角色异常").build();
        }

    }

    /**
     * 根据用户id修改分配对应的角色
     */
    @ResponseBody
    @RequestMapping(value = "/updateUserRoleList", name = "根据用户id修改分配对应的角色")
    public Map<String, Object> updateUserRoleList(String id, String hasRoleList) {
        log.info("开始根据用户id修改分配对应的角色");
        log.info("传入的参数为id:{},hasRoleList:{}}", id, hasRoleList);
        Map<String, Object> map = iRoleService.updateUserRoleList(id, hasRoleList);
        log.info("根据用户id修改分配对应的角色结束");
        return map;
    }

    // -----角色管理系统

    /**
     * 增加角色
     *
     * @param request
     * @param response
     * @param model
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/addRole", method = RequestMethod.POST, name = "增加角色")
    public Map<String, Object> addRole(Role role) {
        log.info("开始增加角色");
        log.info("传入的参数为role:{}", role);
        Map<String, Object> map = iRoleService.addRole(role);
        log.info("增加角色结束");
        return map;
    }

    /**
     * 查询角色
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/selectRoleInfo", method = RequestMethod.POST, name = "查询角色列表")
    public ResponseTemplate selectRoleInfo(Role role) {

        /**
         * 根据用户id进行查看角色
         */
        log.info("开始查询角色");
        log.info("传入的参数为role:{}", role);
        Role roleEntity = iRoleService.selectRoleInfo(role);
        log.info("查询角色结束");
        if (!StringUtils.isEmpty(roleEntity)) {
            return ResponseTemplate.builder().data(roleEntity).code(0).build(); // code 0 代表成功 code1 代表失败
        } else {
            return ResponseTemplate.builder().code(1).message("根据用户id进行查看角色异常").build();
        }

    }

    /**
     * 修改角色
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/updateRole", method = RequestMethod.POST, name = "修改角色")
    public ResponseTemplate updateRole(String id, String roleName, String remarks) {

        /**
         * 根据用户id进行修改角色
         */
        log.info("开始修改角色");
        log.info("传入的参数为id:{},roleName:{},remarks:{}", id, roleName, remarks);
        Integer num = iRoleService.updateRole(id, roleName, remarks);
        log.info("修改角色结束");
        if (num > 0) {
            return ResponseTemplate.builder().code(0).build(); // code 0 代表成功 code1 代表失败
        } else {
            return ResponseTemplate.builder().code(1).message("根据用户id进行修改角色异常").build();
        }

    }

    /**
     * 根据角色id删除角色
     */
    @ResponseBody
    @RequestMapping(value = "/deleteRole", method = RequestMethod.POST, name = "删除角色")
    public ResponseTemplate deleteRole(String id) {
        /**
         * 根据角色id删除角色
         */
        log.info("开始根据角色id删除角色");
        log.info("传入的参数为id:{}}", id);
        Integer num = iRoleService.deleteRole(id);
        log.info("根据角色id删除角色结束");
        if (num > 0) {
            return ResponseTemplate.builder().code(0).build();
        } else {
            return ResponseTemplate.builder().code(1).message("根据用户id删除角色异常").build();
        }
    }

    /**
     * 获取角色列表 不带分页
     */
    @ResponseBody
    @RequestMapping(value = "/selectRoleList", method = RequestMethod.POST, name = "获取角色列表")
    public ResponseTemplate selectRoleList() {
        /**
         * 获取角色列表
         */
        log.info("开始获取角色列表");
        List<Role> list = iRoleService.selectRoleList();
        log.info("获取角色列表结束");
        log.info("根据多查询条件查询用户结束");
        if (!StringUtils.isEmpty(list)) {
            return ResponseTemplate.builder().code(0).count(Long.valueOf(list.size())).data(list).build();
        } else {
            return ResponseTemplate.builder().code(1).message("获取角色列表异常").count(Long.valueOf(list.size())).data(list).build();
        }
    }

    /**
     * 获取角色列表
     */
    @ResponseBody
    @RequestMapping(value = "/selectRoleListPage", method = RequestMethod.POST, name = "获取角色列表")
    public ResponseTemplate selectRoleListPage(Integer page, Integer limit) {
        /**
         * 获取角色列表
         */
        log.info("开始获取角色列表");
        List<Role> list = iRoleService.selectRoleList();
        List paging = ListPagingUtil.listPaging(list, page, limit);
        log.info("根据多查询条件查询用户结束");
        if (!StringUtils.isEmpty(list)) {
            return ResponseTemplate.builder().code(0).count(Long.valueOf(list.size())).data(paging).build();
        } else {
            return ResponseTemplate.builder().code(1).message("获取角色列表异常").count(Long.valueOf(list.size())).data(paging).build();
        }
    }

    /**
     * 查询角色
     */
    @ResponseBody
    @RequestMapping(value = "/selectRole", method = RequestMethod.POST, name = "查询角色")
    public ResponseTemplate selectRole(String id, String roleName) {
        /**
         * 查询角色
         */
        log.info("开始查询角色");
        log.info("传入的参数为id:{},roleName:{}}", id, roleName);
        List<Map<String, Object>> list = iRoleService.selectRole(id, roleName);
        log.info("查询角色结束");
        if (!StringUtils.isEmpty(list)) {
            return ResponseTemplate.builder().code(0).data(list).build();
        } else {
            return ResponseTemplate.builder().code(1).message("查询角色异常").data(list).build();
        }
    }
    /**
     * 查询角色
     */
    @ResponseBody
    @RequestMapping(value = "/selectRoleFenye", method = RequestMethod.POST, name = "查询角色")
    public ResponseTemplate selectRoleFenye(String id, String roleName,int page,int limit) {
        /**
         * 查询角色
         */
        log.info("开始查询角色");
        log.info("传入的参数为id:{},roleName:{}}", id, roleName);
//        log.info("查询角色结束");
        return iRoleService.selectRoleFenye(id, roleName,page,limit);

//        if (!StringUtils.isEmpty(list)) {
//            return ResponseTemplate.builder().code(0).data(list).build();
//        } else {
//            return ResponseTemplate.builder().code(1).message("查询角色异常").data(list).build();
//        }
    }

    /**
     * 根据角色id获取已有的权限 和未有的权限列表(弃用)
     */
    @ResponseBody
    @RequestMapping(value = "/selectAuthList", name = "查询权限列表")
    public ResponseTemplate selectAuthList(String id) {
        log.info("开始根据角色id获取已有的权限 和未有的权限列表");
        log.info("传入的参数为id:{}}", id);
        /**
         * 根据角色id获取已有的权限和未有的权限列表
         */
        Map<String, Object> map = IUserService.selectAuthList(id);
        log.info("根据角色id获取已有的权限 和未有的权限列表结束");
        return ResponseTemplate.builder().code(0).data(map).build();
    }

    /**
     * 根据角色id获取已有的权限
     */
    @ResponseBody
    @RequestMapping(value = "/selectAuthListById", name = "根据角色id获取已有的权限")
    public ResponseTemplate selectAuthListById(String id) {
        log.info("开始根据角色id获取已有的权限");
        log.info("传入的参数为id:{}}", id);
        Map<String, Object> map = IUserService.selectAuthListById(id);
        log.info("根据角色id获取已有的权限结束");
        return ResponseTemplate.builder().code(0).data(map).build();
    }

    /**
     * 根据角色id获取已有的权限
     */
    @ResponseBody
    @RequestMapping(value = "/selectAuthListById2", name = "根据角色id获取已有的权限")
    public ResponseTemplate selectAuthListById2(String id) {
        log.info("开始根据角色id获取已有的权限");
        log.info("传入的参数为id:{}}", id);
        List<Permission> list = IUserService.selectAuthListById2(id);
        log.info("根据角色id获取已有的权限结束");
        return ResponseTemplate.builder().code(0).data(list).build();
    }

    /**
     * 根据用户id获取已有的角色
     */
    @ResponseBody
    @RequestMapping(value = "/selectRoleListByUserId", name = "根据用户id获取已有的角色")
    public ResponseTemplate selectRoleListByUserId(int id) {
        log.info("开始根据用户id获取已有的角色");
        log.info("传入的参数为id:{}}", id);
        List<Role> map = IUserService.selectRoleListByUserId(id);
        log.info("根据用户id获取已有的角色结束");
        return ResponseTemplate.builder().code(0).data(map).build();
    }

    /**
     * 根据角色分配对应的权限 (弃用)
     */
    @ResponseBody
    @RequestMapping(value = "/insertAuthList", name = "分配权限列表")
    public Map<String, Object> insertAuthList(String id, String hasAuthList) {

        /**
         * 根据角色id分配权限列表
         */
        log.info("开始根据角色id分配对应的权限");
        log.info("传入的参数为id:{},hasAuthList:{}}", id, hasAuthList);
        Map<String, Object> map = iRoleService.insertAuthList(id, hasAuthList);
        log.info("根据角色id分配对应的权限结束");
        return map;
    }

    /**
     * 添加角色并分配对应的权限
     */
    @ResponseBody
    @RequestMapping(value = "/insertRoleAuthList", name = "添加角色并分配对应的权限")
    public Map<String, Object> insertRoleAuthList(Role role) {

        /**
         * 添加角色并分配对应的权限
         */
        log.info("开始添加角色并分配对应的权限");
        log.info("传入的参数为role:{}", role);
        Map<String, Object> map = iRoleService.insertRoleAuthList(role);
        log.info("添加角色并分配对应的权限");
        return map;
    }

    /**
     * 根据角色id修改分配对应的权限
     *
     * @param rolePermissionEntity roleId//角色 rolePermissionEntityList//存放所有页面的id
     *                             parentId//该页面的id list//存放该页面所有按钮的id chilrdId
     *                             所有按钮的id
     */
    @ResponseBody
    @RequestMapping(value = "/updateRoleAuthList", method = RequestMethod.POST, name = "修改角色并修改分配对应的权限")
    public Map<String, Object> updateRoleAuthList(@RequestBody RolePermissionEntity rolePermissionEntity) {
        /**
         * 修改角色并修改分配对应的权限
         */
        log.info("开始修改角色并修改分配对应的权限");
        log.info("传入的参数为rolePermissionEntity:{}}", rolePermissionEntity);
        System.out.println(rolePermissionEntity.toString());
        StringBuffer hasAuthList = new StringBuffer();
        String id = rolePermissionEntity.getRoleId();
        // 存放所有权限id的数组
        List<String> list = new ArrayList<>();
        // 存放该角色拥有的该子页面的按钮集合id
        List<Long> listSon = new ArrayList<>();

        List<RolePermissionEntityList> rolePermissionEntityList = rolePermissionEntity.getRolePermissionEntityList();
        for (RolePermissionEntityList rolePermissionEntityList2 : rolePermissionEntityList) {
            if (!StringUtils.isEmpty(rolePermissionEntityList2.getId())) {
                // 存放子集id
                list.add(rolePermissionEntityList2.getId());
                List<PageBtn> list2 = rolePermissionEntityList2.getList();
                if (!ListUtil.isEmpty(list2)) {
                    for (PageBtn pageBtn : list2) {
                        listSon.add(pageBtn.getChilrdId());
                    }
                }

            }
            if (!StringUtils.isEmpty(rolePermissionEntityList2.getParentId())) {
                // 存放带有重复的父集id
                list.add(rolePermissionEntityList2.getParentId());
            }
        }
        // 对存放parentId的数组进行去重处理
        List<String> listNew = new ArrayList<String>(new TreeSet<String>(list));
        for (String parentIdstr : listNew) {
            hasAuthList.append(parentIdstr).append(",");
        }
        String hasAuthList2 = hasAuthList.toString();
        if (hasAuthList2.endsWith(",")) {
            hasAuthList2 = hasAuthList2.substring(0, hasAuthList2.length() - 1);
        }
        System.out.println("最后的字符hasAuthList2:" + hasAuthList2);
        Map<String, Object> map = iRoleService.updateRoleAuthList(id, hasAuthList2);

        // 重新添加该角色对该页面拥有的按钮集合
        for (Long chilrdId : listSon) {
            Integer num = iRoleService.addRolePermission(id, chilrdId);
        }

        log.info("修改角色并修改分配对应的权限结束");
        return map;
    }

    // -----权限管理 (弃用了)
    @ResponseBody
    @RequestMapping(value = "/selectPermissionList", method = RequestMethod.POST, name = "查询权限列表")
    public ResponseTemplate selectPermissionList() {
        /**
         * 查询权限列表
         */
        log.info("开始查询权限列表");
        List<Map<String, Object>> list = iPermissionService.selectPermissionList();
        log.info("查询权限列表结束");
        if (!StringUtils.isEmpty(list)) {
            return ResponseTemplate.builder().code(0).data(list).build();
        } else {
            return ResponseTemplate.builder().code(1).message("查询权限列表异常").build();
        }
    }

    @ResponseBody
    @RequestMapping(value = "/selectFirstPermissionList", method = RequestMethod.POST, name = "查询权限列表")
    public ResponseTemplate selectFirstPermissionList() {
        /**
         * 查询父级权限列表
         */
        log.info("开始查询父级权限列表");
        List<Map<String, Object>> list = iPermissionService.selectFirstPermissionList();
        log.info("查询父级权限列表结束");
        if (!StringUtils.isEmpty(list)) {
            return ResponseTemplate.builder().code(0).data(list).build();
        } else {
            return ResponseTemplate.builder().code(1).message("查询父级权限列表异常").build();
        }
    }

    /**
     * 根据条件查询所有权限
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/selectPermission", method = RequestMethod.POST, name = "查询权限")
    public ResponseTemplate selectPermission(String id, String permissionName, Integer page, Integer limit) {

        /**
         * 查询所有的权限
         */
        log.info("开始根据条件查询所有权限");
        log.info("传入的参数为id:{},permissionName:{},page:{},limit:{}}", id, permissionName, page, limit);
        // 1.分页
        PageHelper.startPage(page, limit);
        // 2.查询
        List<Permission> list = iPermissionService.selectPermission(id, permissionName);
        // 3.解析结果
        PageInfo<Permission> info = new PageInfo<>(list);
        log.info("根据条件查询所有权限结束");
        if (!StringUtils.isEmpty(list)) {
            return ResponseTemplate.builder().code(0).data(list).count((Long) info.getTotal()).build();
        } else {
            return ResponseTemplate.builder().code(1).message("根据条件查询所有权限异常").build();
        }

    }
    @ResponseBody
    @RequestMapping(value = "/selectPermissionAll", method = RequestMethod.POST, name = "查询权限")
    public ResponseTemplate selectPermissionAll(String id, String permissionName) {

        /**
         * 查询所有的权限
         */
        log.info("开始根据条件查询所有权限");

        // 1.分页

        // 2.查询
        List<Permission> list = iPermissionService.selectPermission(id, permissionName);
        // 3.解析结果

        log.info("根据条件查询所有权限结束");
        if (!StringUtils.isEmpty(list)) {
            return ResponseTemplate.builder().code(0).data(list).count(Long.valueOf(list.size())).build();
        } else {
            return ResponseTemplate.builder().code(1).message("根据条件查询所有权限异常").build();
        }

    }
    /**
     * 添加权限
     *
     * @param permission List<Permission> children
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/addPermission", method = RequestMethod.POST, name = "添加权限")
    public ResponseTemplate addPermission(@RequestBody Permission permission) {
        /**
         * 添加权限
         */
        log.info("开始添加权限");
        log.info("传入的参数为permission:{}", permission);
        // 根据权限名字查看是否存在
        Integer numStr = iPermissionService.selectPermissionByName(permission.getPermissionName());

        if (numStr != null) {// 存在
            log.info("添加权限结束");
            return ResponseTemplate.builder().code(1).message("权限名已存在").build();
        } else {
            Integer num = iPermissionService.addPermission(permission);
            log.info("添加权限结束");
            if (num > 0) {
                return ResponseTemplate.builder().code(0).build(); // code 0 代表成功 code1 代表失败
            } else {
                return ResponseTemplate.builder().code(1).message("添加权限异常").build();
            }
        }

    }

    /**
     * 修改权限
     *
     * @param permission List<Permission> children
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/updatePermission", method = RequestMethod.POST, name = "修改权限")
    public ResponseTemplate updatePermission(@RequestBody Permission permission) {
        /**
         * 根据id修改权限
         */
        log.info("开始根据id修改权限");
        log.info("传入的参数为permission:{}}", permission);
        Integer num = iPermissionService.updatePermission(permission);
        log.info("根据id修改权限结束");
        if (num > 0) {
            return ResponseTemplate.builder().code(0).build(); // code 0 代表成功 code1 代表失败
        } else {
            return ResponseTemplate.builder().code(1).message("根据id修改权限异常").build();
        }
    }

    /**
     * 根据id删除权限
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/deletePermission", method = RequestMethod.POST, name = "删除权限")
    public ResponseTemplate deletePermission(String id) {
        /**
         * 根据id删除权限
         */
        log.info("开始根据id删除权限");
        log.info("传入的参数为id:{}", id);
        Integer num = iPermissionService.deletePermission(id);
        log.info("根据id删除权限结束");
        if (num > 0) {
            return ResponseTemplate.builder().code(0).build();
        } else {
            return ResponseTemplate.builder().code(1).message("根据id删除权限异常").build();
        }
    }

    /**
     * 根据id查看权限
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/selectPermissionById", method = RequestMethod.POST, name = "根据id查看权限")
    public ResponseTemplate selectPermissionById(String id) {
        /**
         * 根据id查看权限
         */
        log.info("开始根据id查看权限");
        log.info("传入的参数为id:{}", id);
        Permission permission = iPermissionService.selectPermissionById(id);
        log.info("根据id查看权限结束");
        return ResponseTemplate.builder().data(permission).code(0).build();
    }

    /**
     * 根据父级的id获取旗下的子级id数量
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/selectChirenNumById", method = RequestMethod.POST, name = "根据id查看权限")
    public ResponseTemplate selectChirenNumById(String id) {
        /**
         * 根据id查看权限
         */
        log.info("开始根据父级的id获取旗下的子级id数量");
        log.info("传入的参数为id:{}", id);
        String num = iPermissionService.selectChirenNumById(id);
        log.info("根据父级的id获取旗下的子级id数量结束");
        return ResponseTemplate.builder().data(num).code(0).build();
    }

    /**
     * 根据token返回对象
     *
     * @param
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/selectUserByToken", method = RequestMethod.POST, name = "根据token查看用户信息")
    public ResponseTemplate selectUserByToken(String Token) {
        log.info("开始根据token返回对象");
        log.info("传入的参数为Token:{}", Token);
        User user = IUserService.selectUserByToken(Token);
        log.info("根据token返回对象结束");
        if (!StringUtils.isEmpty(user)) {
            return ResponseTemplate.builder().code(0).data(user).build();
        } else {
            return ResponseTemplate.builder().code(1).message("根据token返回对象异常").build();
        }
    }

    /**
     * 根据id修改密码
     */
    @ResponseBody
    @RequestMapping(value = "/modifyPassword", method = RequestMethod.POST, name = "根据id修改密码")
    public ResponseTemplate selectUserByToken(int id, String password) {
        log.info("开始根据id修改密码");
        log.info("传入的参数为id:{},password:{}", id, password);
        Integer numInteger = null;
        // 根据id查询该对象是否存在
        User user = IUserService.selectUserById(id);
        if (!StringUtils.isEmpty(user)) {
            numInteger = IUserService.updateUserPassword(id, CommonUtils.md5(password));
        }
        log.info("根据id修改密码结束");
        if (numInteger > 0) {
            return ResponseTemplate.builder().code(0).build();
        } else {
            return ResponseTemplate.builder().code(1).message("根据id修改密码异常").build();
        }
    }

    /**
     * 重置密码
     */
    @ResponseBody
    @RequestMapping(value = "/resetPassword", method = RequestMethod.POST, name = "重置密码")
    public ResponseTemplate resetPassword(int id) {
        log.info("开始根据id重置密码");
        log.info("传入的参数为id:{}", id);
        Integer numInteger = null;
        // 根据id查询该对象是否存在
        User user = IUserService.selectUserById(id);
        if (!StringUtils.isEmpty(user)) {
            numInteger = IUserService.resetPassword(id, CommonUtils.md5("123456"));
        }
        log.info("根据id重置密码结束");
        if (numInteger > 0) {
            return ResponseTemplate.builder().code(0).build();
        } else {
            return ResponseTemplate.builder().code(1).message("根据id重置密码异常").build();
        }
    }

    /**
     * 测试专用
     */
    @ResponseBody
    @RequestMapping(value = "/insertUser")
    public ResponseTemplate insertUser() {
        List list = new ArrayList();
        list.add("zhangsan");
        list.add("lisi");
        return ResponseTemplate.builder().code(0).message("请求成功").count(Long.valueOf(100)).data(list).build();
    }

    @ResponseBody
    @RequestMapping(value = "/getUserOrderByDepartment")
    public ResponseTemplate getUserOrderByDepartment() {
        return ResponseTemplate.builder().code(0).message("请求成功").count(Long.valueOf(IUserService.getUserOrderByDepartment().size())).data(IUserService.getUserOrderByDepartment()).build();
    }
}
